home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 039a / mawk10.zip / DA.C < prev    next >
C/C++ Source or Header  |  1991-10-05  |  10KB  |  399 lines
  1.  
  2. /********************************************
  3. da.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the AWK programming language.
  8.  
  9. Mawk is distributed without warranty under the terms of
  10. the GNU General Public License, version 2, 1991.
  11. ********************************************/
  12.  
  13.  
  14. /* $Log:    da.c,v $
  15.  * Revision 3.3.1.1  91/09/14  17:22:56  brennan
  16.  * VERSION 1.0
  17.  * 
  18.  * Revision 3.3  91/08/13  06:51:02  brennan
  19.  * VERSION .9994
  20.  * 
  21.  * Revision 3.2  91/06/28  04:16:24  brennan
  22.  * VERSION 0.999
  23.  * 
  24.  * Revision 3.1  91/06/07  10:27:08  brennan
  25.  * VERSION 0.995
  26.  * 
  27.  * Revision 2.2  91/06/06  09:21:54  brennan
  28.  * added static decl to make STARDENT compiler happy
  29.  * 
  30.  * Revision 2.1  91/04/08  08:22:50  brennan
  31.  * VERSION 0.97
  32.  * 
  33. */
  34.  
  35.  
  36. /*  da.c  */
  37. /*  disassemble code */ 
  38.  
  39.  
  40. #include  "mawk.h"
  41. #include  "code.h"
  42. #include  "bi_funct.h"
  43. #include  "repl.h"
  44. #include  "field.h"
  45.  
  46. static char *PROTO(find_bi_name, (PF_CP) ) ;
  47.  
  48. void  da(start, fp)
  49.   INST *start ;
  50.   FILE *fp ;
  51. { CELL *cp ;
  52.   register INST *p = start ;
  53.  
  54.   while ( 1 )
  55.   { /* print the relative code address (label) */
  56.     fprintf(fp,"%03ld ", (long)(p - start)) ;
  57.  
  58.     switch( p++->op )
  59.     {
  60.       case _HALT :  fprintf(fp,"halt\n") ; return ;
  61.       case _STOP :  fprintf(fp,"stop\n") ; break  ;
  62.       case _STOP0 : fprintf(fp, "stop0\n") ; break ;
  63.  
  64.       case _PUSHC :
  65.             cp = (CELL *) p++->ptr ;
  66.             switch( cp->type )
  67.             { case C_DOUBLE :
  68.                   fprintf(fp,"pushc\t%.6g\n" ,  cp ->dval) ;
  69.                   break ;
  70.  
  71.               case C_STRING :
  72.                   fprintf(fp,"pushc\t\"%s\"\n" ,
  73.                           ((STRING *)cp->ptr)->str) ;
  74.                   break ;
  75.  
  76.               case C_RE :
  77.                   fprintf(fp,"pushc\t0x%lx\t/%s/\n" , (long)cp->ptr ,
  78.                     re_uncompile(cp->ptr) ) ;
  79.                   break ;
  80.  
  81.               case C_SPACE : 
  82.                   fprintf(fp, "pushc\tspace split\n") ;
  83.                   break ;
  84.  
  85.               case C_SNULL : 
  86.                   fprintf(fp, "pushc\tnull split\n") ;
  87.                   break ;
  88.               case C_REPL  :
  89.                   fprintf(fp, "pushc\trepl\t%s\n" ,
  90.                         repl_uncompile(cp) ) ;
  91.                   break ;
  92.               case C_REPLV :
  93.                   fprintf(fp, "pushc\treplv\t%s\n" ,
  94.                         repl_uncompile(cp) ) ;
  95.                   break ;
  96.                   
  97.               default :
  98.                   fprintf(fp,"pushc\tWEIRD\n") ;  ;
  99.                   break ;
  100.             }
  101.             break ;
  102.  
  103.       case _PUSHA :
  104.             fprintf(fp,"pusha\t0x%lx\n", (long)(p++ -> ptr)) ;
  105.             break ;
  106.  
  107.       case _PUSHI :
  108.             if ( (CELL *)p->ptr == field )
  109.                 fprintf(fp, "pushi\t$0\n") ;
  110.             else fprintf(fp,"pushi\t0x%lx\n", (long)(p -> ptr)) ;
  111.             p++ ;
  112.             break ;
  113.  
  114.       case  L_PUSHA :
  115.             fprintf( fp, "l_pusha\t%d\n", p++->op) ;
  116.             break ;
  117.  
  118.       case  L_PUSHI :
  119.             fprintf( fp, "l_pushi\t%d\n", p++->op) ;
  120.             break ;
  121.  
  122.       case  LAE_PUSHI :
  123.             fprintf( fp, "lae_pushi\t%d\n", p++->op) ;
  124.             break ;
  125.  
  126.       case  LAE_PUSHA :
  127.             fprintf( fp, "lae_pusha\t%d\n", p++->op) ;
  128.             break ;
  129.  
  130.       case  LA_PUSHA :
  131.             fprintf( fp, "la_pusha\t%d\n", p++->op) ;
  132.             break ;
  133.  
  134.       case F_PUSHA :
  135.             fprintf(fp,"f_pusha\t$%ld\n" , (long)((CELL *)p++->ptr - field) ) ;
  136.             break ;
  137.  
  138.       case F_PUSHI :
  139.             fprintf(fp,"f_pushi\t$%ld\n" , (long)((CELL *)p++->ptr - field) ) ;
  140.             break ;
  141.  
  142.       case FE_PUSHA :
  143.             fprintf(fp,"fe_pusha\n" ) ;
  144.             break ;
  145.  
  146.       case FE_PUSHI :
  147.             fprintf(fp,"fe_pushi\n" ) ;
  148.             break ;
  149.  
  150.       case AE_PUSHA :
  151.             fprintf(fp,"ae_pusha\t0x%lx\n" , (long)(p++->ptr)) ;
  152.             break ;
  153.  
  154.       case AE_PUSHI :
  155.             fprintf(fp,"ae_pushi\t0x%lx\n" , (long)(p++->ptr)) ;
  156.             break ;
  157.  
  158.       case A_PUSHA :
  159.             fprintf(fp,"a_pusha\t0x%lx\n" , (long)(p++->ptr)) ;
  160.             break ;
  161.  
  162.       case A_TEST :
  163.             fprintf(fp,"a_test\n" ) ;
  164.             break ;
  165.  
  166.       case A_DEL :
  167.             fprintf(fp,"a_del\n" ) ;
  168.             break ;
  169.  
  170.       case A_CAT :
  171.             fprintf(fp,"a_cat\t%d\n", p++->op ) ;
  172.             break ;
  173.  
  174.       case _POP :
  175.             fprintf(fp,"pop\n") ;
  176.             break ;
  177.  
  178.       case  _ADD :
  179.             fprintf(fp,"add\n") ; break ;
  180.  
  181.       case  _SUB :
  182.             fprintf(fp,"sub\n") ; break ;
  183.       case  _MUL :
  184.             fprintf(fp,"mul\n") ; break ;
  185.       case  _DIV :
  186.             fprintf(fp,"div\n") ; break ;
  187.       case  _MOD :
  188.             fprintf(fp,"mod\n") ; break ;
  189.       case  _POW :
  190.             fprintf(fp,"pow\n") ; break ;
  191.       case  _NOT :
  192.             fprintf(fp,"not\n") ; break ;
  193.       case  _UMINUS :
  194.             fprintf(fp,"uminus\n") ; break ;
  195.       case  _UPLUS :
  196.             fprintf(fp,"plus\n") ; break ;
  197.       case  _DUP :
  198.             fprintf(fp,"dup\n") ; break ;
  199.       case  _TEST :
  200.             fprintf(fp,"test\n") ; break ;
  201.  
  202.       case  _CAT  :
  203.             fprintf(fp,"cat\n") ; break ;
  204.  
  205.       case  _ASSIGN :
  206.             fprintf(fp,"assign\n") ; break ;
  207.       case  _ADD_ASG :
  208.             fprintf(fp,"add_asg\n") ; break ;
  209.       case  _SUB_ASG :
  210.             fprintf(fp,"sub_asg\n") ; break ;
  211.       case  _MUL_ASG :
  212.             fprintf(fp,"mul_asg\n") ; break ;
  213.       case  _DIV_ASG :
  214.             fprintf(fp,"div_asg\n") ; break ;
  215.       case  _MOD_ASG :
  216.             fprintf(fp,"mod_asg\n") ; break ;
  217.       case  _POW_ASG :
  218.             fprintf(fp,"pow_asg\n") ; break ;
  219.  
  220.       case  F_ASSIGN :
  221.             fprintf(fp,"f_assign\n") ; break ;
  222.       case  F_ADD_ASG :
  223.             fprintf(fp,"f_add_asg\n") ; break ;
  224.       case  F_SUB_ASG :
  225.             fprintf(fp,"f_sub_asg\n") ; break ;
  226.       case  F_MUL_ASG :
  227.             fprintf(fp,"f_mul_asg\n") ; break ;
  228.       case  F_DIV_ASG :
  229.             fprintf(fp,"f_div_asg\n") ; break ;
  230.       case  F_MOD_ASG :
  231.             fprintf(fp,"f_mod_asg\n") ; break ;
  232.       case  F_POW_ASG :
  233.             fprintf(fp,"f_pow_asg\n") ; break ;
  234.  
  235.       case  _PUSHINT :
  236.             fprintf(fp,"pushint\t%d\n" , p++ -> op ) ;
  237.             break ;
  238.  
  239.       case  _BUILTIN  :
  240.             fprintf(fp,"%s\n" , 
  241.                     find_bi_name( (PF_CP) p++ -> ptr ) ) ;
  242.             break ;
  243.  
  244.       case  _PRINT :
  245.             fprintf(fp,"%s\n", 
  246.             (PF_CP) p++ -> ptr == bi_printf
  247.                 ? "printf" : "print") ;
  248.             break ;
  249.       
  250.       case  _POST_INC :
  251.             fprintf(fp,"post_inc\n") ; break ;
  252.  
  253.       case  _POST_DEC :
  254.             fprintf(fp,"post_dec\n") ; break ;
  255.  
  256.       case  _PRE_INC :
  257.             fprintf(fp,"pre_inc\n") ; break ;
  258.  
  259.       case  _PRE_DEC :
  260.             fprintf(fp,"pre_dec\n") ; break ;
  261.  
  262.       case  F_POST_INC :
  263.             fprintf(fp,"f_post_inc\n") ; break ;
  264.  
  265.       case  F_POST_DEC :
  266.             fprintf(fp,"f_post_dec\n") ; break ;
  267.  
  268.       case  F_PRE_INC :
  269.             fprintf(fp,"f_pre_inc\n") ; break ;
  270.  
  271.       case  F_PRE_DEC :
  272.             fprintf(fp,"f_pre_dec\n") ; break ;
  273.  
  274.       case  _JMP :
  275.       case  _JNZ :
  276.       case  _JZ  :
  277.           { int j = (p-1)->op ;
  278.             char *s = j == _JMP ? "jmp" : 
  279.                       j == _JNZ ? "jnz" : "jz" ;
  280.  
  281.             fprintf(fp,"%s\t\t%03ld\n" , s ,
  282.               (long)((p - start) + p->op - 1) ) ;
  283.             p++ ;
  284.             break ;
  285.           }
  286.     
  287.       case  _EQ  :
  288.             fprintf(fp,"eq\n") ; break ;
  289.  
  290.       case  _NEQ  :
  291.             fprintf(fp,"neq\n") ; break ;
  292.  
  293.       case  _LT  :
  294.             fprintf(fp,"lt\n") ; break ;
  295.  
  296.       case  _LTE  :
  297.             fprintf(fp,"lte\n") ; break ;
  298.  
  299.       case  _GT  :
  300.             fprintf(fp,"gt\n") ; break ;
  301.  
  302.       case  _GTE  :
  303.             fprintf(fp,"gte\n") ; break ;
  304.  
  305.       case  _MATCH :
  306.             fprintf(fp,"match_op\n") ; break ;
  307.  
  308.       case  A_LOOP :
  309.             fprintf(fp,"a_loop\t%03ld\n", (long)(p-start+p[1].op)) ;
  310.             p += 2 ;
  311.             break ;
  312.  
  313.       case  _EXIT  :
  314.             fprintf(fp, "exit\n") ; break ;
  315.  
  316.       case  _EXIT0  :
  317.             fprintf(fp, "exit0\n") ; break ;
  318.  
  319.       case  _NEXT  :
  320.             fprintf(fp, "next\n") ; break ;
  321.  
  322.       case  _RET  :
  323.             fprintf(fp, "ret\n") ; break ;
  324.       case  _RET0 :
  325.             fprintf(fp, "ret0\n") ; break ;
  326.  
  327.       case  _CALL :
  328.             fprintf(fp, "call\t%s\t%d\n", 
  329.                 ((FBLOCK*)p->ptr)->name , p[1].op) ;
  330.             p += 2 ;
  331.             break ;
  332.  
  333.       case  _RANGE :
  334.             fprintf(fp, "range\t%03d %03d %03d\n",
  335.               /* label for pat2, action, follow */
  336.               (long)(p - start + p[1].op) ,
  337.               (long)(p - start + p[2].op) ,
  338.               (long)(p - start + p[3].op) ) ;
  339.             p += 4 ; 
  340.             break ;
  341.       default :
  342.             fprintf(fp,"bad instruction\n") ;
  343.             return ;
  344.     }
  345.   }
  346. }
  347.  
  348. static struct {
  349. PF_CP action ;
  350. char *name ;
  351. } special_cases[] = {
  352. bi_length, "length",
  353. bi_split, "split",
  354. bi_match, "match",
  355. bi_getline,"getline",
  356. bi_sub, "sub",
  357. bi_gsub , "gsub",
  358. (PF_CP) 0, (char *) 0 } ;
  359.  
  360. static char *find_bi_name( p )
  361.   PF_CP p ;
  362. { BI_REC *q ;
  363.   int i ;
  364.  
  365.   for( q = bi_funct ; q->name ; q++ )
  366.     if ( q->fp == p )  /* found */
  367.         return q->name ;
  368.   /* next check some special cases */
  369.   for( i = 0 ; special_cases[i].action ; i++)
  370.     if ( special_cases[i].action == p )
  371.         return  special_cases[i].name ;
  372.  
  373.   return  "unknown builtin" ;
  374. }
  375.  
  376. static struct fdump {
  377. struct fdump *link ;
  378. FBLOCK  *fbp ;
  379. }  *fdump_list ;  /* linked list of all user functions */
  380.  
  381. void add_to_fdump_list( fbp )
  382.   FBLOCK *fbp ;
  383. { struct fdump *p = (struct fdump *)zmalloc(sizeof(struct fdump)) ;
  384.   p->fbp = fbp ;
  385.   p->link = fdump_list ;  fdump_list = p ;
  386. }
  387.  
  388. void  fdump()
  389. {
  390.   register struct fdump *p, *q = fdump_list ;
  391.  
  392.   while ( p = q )
  393.   { q = p->link ;
  394.     fprintf(stderr, "function %s\n" , p->fbp->name) ;
  395.     da(p->fbp->code, stderr) ;
  396.     zfree(p, sizeof(struct fdump)) ;
  397.   }
  398. }
  399.